#include "../common/dispatcher.hpp"
#include "../client/rpc_client.hpp"
#include "rpc_router.hpp"
#include "rpc_registry.hpp"
#include "rpc_topic.hpp"

namespace bitrpc {
    namespace server {
        //注册中心服务端
        //作为服务注册与发现的中心节点，负责：
        //1. 接收并处理服务注册请求
        //2. 维护服务名称与地址的映射关系
        //3. 响应服务发现请求
        //4. 处理连接断开事件，清理相关资源

        class RegistryServer {
            public:
                using ptr = std::shared_ptr<RegistryServer>;

                //初始化注册中心服务器：
                //1. 创建发布-发现管理器(PDManager)
                //2. 创建消息分布器（Dispatcher)
                //3. 注册服务请求处理回调
                //4. 创建服务器并设置消息回调和连接关闭回调
                RegistryServer(int port):
                    _pd_manager(std::make_shared<PDManager>()),
                    _dispatcher(std::make_shared<bitrpc::Dispatcher>())
                {
                    //注册服务请求处理回调函数
                    auto service_cb = std::bind(&PDManager::onServiceRequest, _pd_manager.get(),
                        std::placeholders::_1, std::placeholders::_2);
                    _dispatcher->registerHandler<ServiceRequest>(MType::REQ_SERVICE, service_cb);

                   //创建服务器实例 
                    _server = bitrpc::ServerFactory::create(port);
                    
                    //设置消息处理回调
                    auto message_cb = std::bind(&bitrpc::Dispatcher::othirdnMessage, _dispatcher.get(), 
                        std::placeholders::_1, std::placeholders::_2);
                    _server->setMessageCallback(message_cb);

                    //设置连接关闭回调
                    auto close_cb = std::bind(&RegistryServer::onConnShutdown, this, std::placeholders::_1);
                    _server->setCloseCallback(close_cb);
                }

                //启动服务器
                void start() {
                    _server->start();
                }
            private:        
            //处理连接关闭事件：当客户端连接断开时，通知PDManager清除相关资源
                void onConnShutdown(const BaseConnection::ptr &conn) {
                    _pd_manager->onConnShutdown(conn);
                }
            private:
                PDManager::ptr _pd_manager;     //发布-发现管理器
                Dispatcher::ptr _dispatcher;    //消息分布器
                BaseServer::ptr _server;        //服务器示实例
        };

        //RPC服务端
        //提供PRC服务的核心组件，负责：
        //1. 接收并处理RPC请求
        //2. 将请求路由到对应的服务处理方法
        //3. 支持服务注册到注册中心（可选功能）
        //4. 管理服务描述信息
        class RpcServer {
            public:
                using ptr = std::shared_ptr<RpcServer>;
                //rpc——server端有两套地址信息：
                //  1. rpc服务提供端地址信息--必须是rpc服务器对外访问地址（云服务器---监听地址和访问地址不同）
                //  2. 注册中心服务端地址信息 -- 启用服务注册后，连接注册中心进行服务注册用的

                //初始化RPC服务器：
                //1. 设置访问地址和注册中心相关配置
                //2. 创建RPC路由器和消息分发器
                //3. 可选创建注册中心客户端
                //4. 注册RPC请求处理回调
                //5. 创建服务器并设置消息回调
                RpcServer(const Address &access_addr, 
                    bool enableRegistry = false, 
                    const Address &registry_server_addr = Address()):
                    _enableRegistry(enableRegistry),
                    _access_addr(access_addr),
                    _router(std::make_shared<bitrpc::server::RpcRouter>()),
                    _dispatcher(std::make_shared<bitrpc::Dispatcher>()) {
                    
                    // 如果启用服务注册，创建注册中心客户端
                    if (enableRegistry) {
                        _reg_client = std::make_shared<client::RegistryClient>(
                            registry_server_addr.first, registry_server_addr.second);
                    }
                    //当前成员server是一个rpcserver，用于提供rpc服务的
                    //注册RPC请求处理回调
                    auto rpc_cb = std::bind(&RpcRouter::onRpcRequest, _router.get(), 
                        std::placeholders::_1, std::placeholders::_2);
                    _dispatcher->registerHandler<bitrpc::RpcRequest>(bitrpc::MType::REQ_RPC, rpc_cb);

                    //创建服务器实例并设置消息回调
                    _server = bitrpc::ServerFactory::create(access_addr.second);
                    auto message_cb = std::bind(&bitrpc::Dispatcher::onMessage, _dispatcher.get(), 
                        std::placeholders::_1, std::placeholders::_2);
                    _server->setMessageCallback(message_cb);
                }
                //注册服务方法：
                //1.如果启动了服务注册，将服务注册到注册中心
                //2.在本地路由器中注册服务方法
                void registerMethod(const ServiceDescribe::ptr &service) {
                    if (_enableRegistry) {
                        _reg_client->registryMethod(service->method(), _access_addr);
                    }
                    _router->registerMethod(service);
                }
                //启动服务器
                void start() {
                    _server->start();
                }
            private:
                bool _enableRegistry;                       //是否启动服务注册
                Address _access_addr;                       //RPC服务对外访问地址
                client::RegistryClient::ptr _reg_client;    //注册中心客户端
                RpcRouter::ptr _router;                     //RPC路由器
                Dispatcher::ptr _dispatcher;                //消息分发器
                BaseServer::ptr _server;                    //服务器实例
        };

        //主题服务端
        //实现发布-订阅模式的消息服务，负责：
        //1.处理主题创建、删除请求
        //2.管理订阅关系
        //3.分发发布的消息到订阅者
        //4.处理连接断开事件，清理订阅关系

        class TopicServer {
            public:
                using ptr = std::shared_ptr<TopicServer>;

                //初始化主题服务器：
                //1. 创建主题管理器和消息分发器
                //2. 注册主题请求处理回调
                //3. 创建服务器并设置消息回调和连接关闭回调
                TopicServer(int port):
                    _topic_manager(std::make_shared<TopicManager>()),
                    _dispatcher(std::make_shared<bitrpc::Dispatcher>())
                {
                    //注册主题请求处理回调
                    auto topic_cb = std::bind(&TopicManager::onTopicRequest, _topic_manager.get(),
                        std::placeholders::_1, std::placeholders::_2);
                    _dispatcher->registerHandler<TopicRequest>(MType::REQ_TOPIC, topic_cb);

                    //创建服务器实例并设置消息回调
                    _server = bitrpc::ServerFactory::create(port);
                    auto message_cb = std::bind(&bitrpc::Dispatcher::onMessage, _dispatcher.get(), 
                        std::placeholders::_1, std::placeholders::_2);
                    _server->setMessageCallback(message_cb);

                    //设置连接关闭回调
                    auto close_cb = std::bind(&TopicServer::onConnShutdown, this, std::placeholders::_1);
                    _server->setCloseCallback(close_cb);
                }
                //启动服务器
                void start() {
                    _server->start();
                }
            private:
            //处理连接关闭事件：当客户端连接断开时，通知TopicManager清理订阅关系
                void onConnShutdown(const BaseConnection::ptr &conn) {
                    _topic_manager->onShutdown(conn);
                }
            private:
                TopicManager::ptr _topic_manager;   //主题管理器
                Dispatcher::ptr _dispatcher;        //消息分布器
                BaseServer::ptr _server;            //服务器实例
        };
    }
}